package jpnms.src;

import org.junit.Test;

import java.io.*;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class BaseDtype {

    /**
     * 1.基本数据类型
     * <p>
     * 一、变量按照数据类型来分：
     * 基本数据类型：
     * 整型：byte \ short \ int \ long
     * 浮点型：float \ double
     * 字符型：char
     * 布尔型：boolean
     * <p>
     * 引用数据类型：
     * 类：class
     * 接口：interface
     * 数组：array
     * <p>
     * 基本数据类型之间的运算规则：
     * <p>
     * 前提：这里讨论只是7中基本数据类型变量的运算。不包含boolean类型的。
     * 1. 自动类型提升：
     * 当容量小的数据类型的变量和容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
     * byte-->short-->int-->long-->float-->double
     * char、byte、short-->int-->long-->float-->double
     * <p>
     * 特别的：当byte、char、short三种类型的变量做运算时，结果为int类型
     * <p>
     * 2. 强制类型转换：
     * <p>
     * 说明：此时容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
     * 3.String类型变量的使用
     * String属于引用数据类型
     * 声明String类型变量时，使用一对""
     * String可以和8种基本数据类型变量做运算，且运算只能是连接运算；+
     * 运算的结果任然是String类型
     **/
    boolean blmax = true, blmin = false;//1bit
    byte bmax = (byte) (Math.pow(2, 7) - 1);//1 byte
    short smax = (short) (Math.pow(2, 15) - 2);//2 byte
    int imax = (int) (Math.pow(2, 31) - 1), imin = -2147483648;//4 byte
    long lmax = (long) (Math.pow(2, 63) - 1);//8 byte
    float fmax = 3.403f; //-3.403E38 ~ 3.403E38
    double dmax = 1.798; //-1.798E308 ~ 1.798E308
    char c1 = 'a'; //2 byte
    char c2 = 68, c3 = '\u0234', c4 = '\n';//数字定义，unicode字符，转义字符
    int n1 = 0b110, n2 = 110, n3 = 0127, n4 = 0x1ADF;//bin,dec,oct,hex
    //类型转换
    //自增不改变数据类型
    //&与 |或  ^异或  !非
    //位运算 >> 相当于/2, <<  相当于*2
    //三元运算符  条件表达式?表达式1:表达式2
    //只有单目运算符、三元运算符、赋值运算符是从右向左运算的


    /**
     * 2.引用类型
     * 数组 []:int [] ,float [] ,char [] ,String []
     * 初始化值:  0    ,  0.0    ,'\u0000', null
     * 多维数组
     * <p>
     * <p>
     * 字符串
     */
    int[] iarr1 = new int[6], iarr2 = {3, 4, 6};
    int[][] iarr3 = new int[6][];
    int[][] iarr4 = new int[][]{{1, 2, 3}, {3, 4, 5}};
    String[] sarr1 = new String[6], sarr2 = {"fr", "fs"};
    String s1 = "sdsfs", s2 = new String();//不可变
    StringBuilder sb1 = new StringBuilder("fsdgd");//可变，线程不安全
    StringBuffer sf1 = new StringBuffer("fggdfd");//可变，线程安全


    /**
     * java  IO
     */

    /**
     * java  re
     * <p>
     * Pattern 类：
     * pattern 对象是一个正则表达式的编译表示。
     * Pattern 类没有公共构造方法。
     * 你必须首先调用其公共静态编译方法，它返回一个 Pattern 对象。
     * 该方法接受一个正则表达式作为它的第一个参数。
     * \\:java中转义的反斜杠
     * ^ $ 开始  结尾
     * * 匹配0次或多次，+ 匹配一次或多次，？ 匹配0或1次,加限定符后面表示非贪心
     * {n,m} 匹配n次到m次   . 匹配任意单个字符
     * (pattern) :匹配并捕获子表达式
     * (?:pattern)：非捕获匹配
     * (?=pattern)：预测先行，不占用字符
     * (?!pattern)：反向预测先行，不占用字符
     * x|y ：或  [xyz] ：字符集  [^zyx]：非字符集 [a-z]：字符集 \d 等效 [0-9] \D 非数字匹配
     * \s 空白字符 \S 非空字符   \f 换页符 \n 换行符  \r  回车符  \t 制表符 \v 垂直制表
     * \w 匹配任意字类字符，包括下划线 [A-Za-z0-9_]  \W
     * \xn 匹配n，16进制转义码  \num 匹配num \n 标识八进制转义码
     * \b ：匹配一个字边界   \B ：非字边界匹配  \cx ：匹配x指示的控制字符
     * <p>
     * Matcher 类：
     * Matcher 对象是对输入字符串进行解释和匹配操作的引擎。
     * 与Pattern 类一样，Matcher 也没有公共构造方法。
     * 调用 Pattern 对象的 matcher 方法来获得一个 Matcher 对象。
     *
     *
     * <p>
     * PatternSyntaxException：
     * PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误
     */
    @Test
    public void testRe() {
        //String method
        s1.length();
        sb1.setCharAt(3, 'd');
        sb1.insert(3, "sdgv");
        //array attr
        int length = iarr1.length;
        String s = iarr1.toString();
        Pattern compile = Pattern.compile("s.*?v", 1);
        Matcher matcher = compile.matcher("svscsvrfbsdfv");
        StringBuffer sb = new StringBuffer();
        while (matcher.find()) {
            System.out.println(matcher.start());
            System.out.println(matcher.end());
            System.out.println(matcher.group());
            matcher.appendReplacement(sb, "--");
        }

        StringBuffer msbb = matcher.appendTail(sb);
        String wang = matcher.replaceAll("wang");
        String jpnms = matcher.replaceFirst("jpnms");
        System.out.println(jpnms);
        System.out.println(wang);
        System.out.println(sb);
        System.out.println(msbb);

//        for (char cc :
//                s1.toCharArray()) {
//            System.out.println(cc);
//        }
    }

    /**
     * java  标准IO
     * System.in;
     * System.out;
     * System.err;
     */
    @Test
    public void testSysIO() {

        Scanner scanner = new Scanner(System.in);
        System.out.println("ScannerTest, Please Enter Name:");
        if (scanner.hasNext()) { //如有下一行
            String s3 = scanner.nextLine();//读取下一行
            String next = scanner.next();//读取下一个字符
            int i = scanner.nextInt();//读取下一个整数
            String inLine = scanner.findInLine("^my");//模板匹配
        }
        File fmain = new File("jpnms/src/main.java");
        try {
            Scanner fm = new Scanner(fmain);
            String s3 = fm.toString();
            System.out.println(s3);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
        try {
            int available = System.in.available();
            System.out.println(available);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    /**
     * java  IO  File
     * 文件——》节点流——》缓存流——》
     * File
     * FileInputStream,FileOutputStream,FileReader,FileWriter;
     * BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter
     *
     * @throws IOException
     */
    @Test
    public void testFile() throws IOException {
        FileInputStream f = new FileInputStream(new File("jpnms/src/main.java"));
        int available = f.available();
        InputStreamReader inputStreamReader = new InputStreamReader(f);
        char[] chars = new char[available];
//        inputStreamReader.read(chars,0,available);
        StringBuilder sb = new StringBuilder();
        while (inputStreamReader.ready()) {
            sb.append((char) inputStreamReader.read());
        }
        System.out.println(sb);
        FileOutputStream fo = new FileOutputStream("jpnms/src/mainn.java");
        OutputStreamWriter ow = new OutputStreamWriter(fo);
        //ow.write(chars);
        ow.close();
        fo.close();
    }
}























